/**
 * Spark创作引擎相关类型定义
 * 支持引导式创作、对话管理、大纲生成和分段内容生成
 */

import { generateId } from './document'

/**
 * 对话步骤类型
 */
export enum DialogStepType {
  TOPIC_CLARIFICATION = 'topic_clarification',    // 主题明确
  AUDIENCE_STYLE = 'audience_style',              // 受众和风格
  STRUCTURE_PLANNING = 'structure_planning',      // 结构规划
  OUTLINE_GENERATION = 'outline_generation',      // 大纲生成
  COMPLETED = 'completed'                         // 对话完成
}

/**
 * 对话步骤接口
 */
export interface DialogStep {
  type: DialogStepType
  question: string
  options?: string[]
  placeholder?: string
  isRequired: boolean
  helpText?: string
}

/**
 * 字数快捷预设配置
 */
export interface WordCountPreset {
  label: string           // 显示名称（如"短文"）
  value: number          // 字数值（如300）
  description: string    // 使用场景说明
}

/**
 * 字数预设常量
 */
export const WORD_COUNT_PRESETS: WordCountPreset[] = [
  { label: '短文', value: 300, description: '快讯、公告' },
  { label: '中篇', value: 800, description: '博客、报告' },
  { label: '长文', value: 1500, description: '深度分析' }
]

/**
 * 段落数量动态计算规则
 * 根据文章总字数，推荐合理的段落数范围
 */
export interface SectionCountRule {
  minWords: number           // 适用的最小字数
  maxWords: number           // 适用的最大字数
  minSections: number        // 最少段落数
  maxSections: number        // 最多段落数
  recommendedSections: number // 推荐段落数
}

/**
 * 段落数规则常量
 */
export const SECTION_COUNT_RULES: SectionCountRule[] = [
  // 超短文：200-400字 → 2-3段
  {
    minWords: 0,
    maxWords: 400,
    minSections: 2,
    maxSections: 3,
    recommendedSections: 2
  },
  // 短文：401-700字 → 3-5段
  {
    minWords: 401,
    maxWords: 700,
    minSections: 3,
    maxSections: 5,
    recommendedSections: 3
  },
  // 中篇：701-1200字 → 4-6段
  {
    minWords: 701,
    maxWords: 1200,
    minSections: 4,
    maxSections: 6,
    recommendedSections: 4
  },
  // 长文：1201-2000字 → 5-8段
  {
    minWords: 1201,
    maxWords: 2000,
    minSections: 5,
    maxSections: 8,
    recommendedSections: 6
  },
  // 超长文：2001+字 → 6-10段
  {
    minWords: 2001,
    maxWords: 9999,
    minSections: 6,
    maxSections: 10,
    recommendedSections: 7
  }
]

/**
 * 用户响应数据
 */
export interface UserResponses {
  topic: string                    // 主题
  purpose: string                  // 创作目的
  audience: string                 // 目标受众
  tone: string                     // 写作风格
  totalWords: number               // 总字数（新增：支持自定义）
  sectionCount: number             // 段落数量（新增：支持自定义）
  structure: string                // 文章结构
  keyPoints: string[]              // 关键要点
}

/**
 * 对话状态管理
 */
export interface SparkDialogState {
  id: string                       // 对话会话ID
  currentStep: number              // 当前步骤索引 (0-based)
  totalSteps: number               // 总步骤数
  sparkInput: string               // 用户输入的火花
  responses: Partial<UserResponses> // 用户回答
  isCompleted: boolean             // 是否完成
  createdAt: Date                  // 创建时间
  updatedAt: Date                  // 更新时间
}

/**
 * 大纲段落类型
 */
export enum OutlineSectionType {
  INTRO = 'intro',                 // 引言
  BODY = 'body',                   // 正文
  CONCLUSION = 'conclusion'        // 结论
}

/**
 * 段落生成状态
 */
export enum SectionStatus {
  PENDING = 'pending',             // 待生成
  GENERATING = 'generating',       // 生成中
  COMPLETED = 'completed',         // 已完成
  ERROR = 'error'                  // 生成错误
}

/**
 * 大纲段落接口
 */
export interface OutlineSection {
  id: string                       // 段落唯一ID
  title: string                    // 段落标题
  type: OutlineSectionType         // 段落类型
  description: string              // 段落描述
  keyPoints: string[]              // 关键要点
  estimatedLength: number          // 预估字数
  status: SectionStatus            // 生成状态
  content?: string                 // 生成的内容
  order: number                    // 段落顺序
}

/**
 * 文章大纲接口
 */
export interface ArticleOutline {
  id: string                       // 大纲唯一ID
  title: string                    // 文章标题
  sections: OutlineSection[]       // 段落列表
  totalEstimatedLength: number     // 总预估字数
  sparkId: string                  // 关联的Spark对话ID
  createdAt: Date                  // 创建时间
  updatedAt: Date                  // 更新时间
}

/**
 * 生成错误接口
 */
export interface GenerationError {
  sectionId: string                // 段落ID
  message: string                  // 错误信息
  retryCount: number               // 重试次数
  timestamp: Date                  // 错误时间
}

/**
 * 内容生成状态
 */
export interface ContentGenerationState {
  currentSectionIndex: number      // 当前生成段落索引
  generationProgress: number       // 生成进度 (0-100)
  errors: GenerationError[]        // 错误列表
  isGenerating: boolean           // 是否正在生成
  tokenUsage: {
    total: number                 // 总消耗token
    perSection: Map<string, number> // 每段落消耗token
  }
}

/**
 * Spark创作完整数据
 */
export interface SparkCreationData {
  id: string                       // 创作会话ID
  sparkInput: string               // 原始火花输入
  dialogState: SparkDialogState    // 对话状态
  outline: ArticleOutline | null   // 生成的大纲
  generationState: ContentGenerationState // 生成状态
  finalContent?: string            // 最终生成的完整文章
  metadata: {
    tokenUsed: number             // 总消耗token
    timeCost: number              // 总耗时(秒)
    completionRate: number        // 完成度(0-1)
  }
  status: 'draft' | 'generating' | 'completed' | 'error' // 整体状态
  createdAt: Date                  // 创建时间
  updatedAt: Date                  // 更新时间
}

/**
 * Token使用优化配置
 */
export interface TokenOptimization {
  cacheCommonResponses: Map<string, string> // 缓存常见回答
  maxSectionLength: number         // 单段最大长度
  concurrentGeneration: boolean    // 是否并发生成
  allowPartialGeneration: boolean  // 允许部分生成
  showTokenUsage: boolean         // 显示token使用情况
  tokenBudgetLimit: number        // token预算限制
}

/**
 * 降级策略配置
 */
export interface FallbackStrategies {
  // 网络错误
  offlineTemplates: ArticleTemplate[]
  
  // Token耗尽
  simplifiedGeneration: boolean
  templateBasedOutline: boolean
  
  // 质量问题
  humanReviewRequired: boolean
  multipleAttempts: number
}

/**
 * 文章模板接口
 */
export interface ArticleTemplate {
  id: string
  name: string
  description: string
  category: string
  outline: OutlineSection[]
  estimatedTokens: number
}

/**
 * AI生成配置
 */
export interface AIGenerationConfig {
  model: string                    // AI模型
  temperature: number              // 创造性程度
  maxTokens: number               // 最大token数
  systemPrompt: string            // 系统提示词
  retryAttempts: number           // 重试次数
  timeout: number                 // 超时时间(秒)
}

/**
 * 创建默认对话状态
 */
export function createDefaultDialogState(sparkInput: string): SparkDialogState {
  return {
    id: generateId(),
    currentStep: 0,
    totalSteps: 4,
    sparkInput,
    responses: {},
    isCompleted: false,
    createdAt: new Date(),
    updatedAt: new Date()
  }
}

/**
 * 创建默认大纲段落
 */
export function createDefaultOutlineSection(
  title: string, 
  type: OutlineSectionType,
  order: number
): OutlineSection {
  return {
    id: generateId(),
    title,
    type,
    description: '',
    keyPoints: [],
    estimatedLength: type === OutlineSectionType.INTRO ? 200 :
                    type === OutlineSectionType.CONCLUSION ? 200 : 400,
    status: SectionStatus.PENDING,
    order
  }
}

/**
 * 创建默认文章大纲
 */
export function createDefaultArticleOutline(
  title: string, 
  sparkId: string
): ArticleOutline {
  const sections = [
    createDefaultOutlineSection('引言', OutlineSectionType.INTRO, 0),
    createDefaultOutlineSection('主要观点', OutlineSectionType.BODY, 1),
    createDefaultOutlineSection('总结', OutlineSectionType.CONCLUSION, 2)
  ]
  
  return {
    id: generateId(),
    title,
    sections,
    totalEstimatedLength: sections.reduce((sum, section) => sum + section.estimatedLength, 0),
    sparkId,
    createdAt: new Date(),
    updatedAt: new Date()
  }
}

/**
 * 创建默认生成状态
 */
export function createDefaultGenerationState(): ContentGenerationState {
  return {
    currentSectionIndex: 0,
    generationProgress: 0,
    errors: [],
    isGenerating: false,
    tokenUsage: {
      total: 0,
      perSection: new Map()
    }
  }
}

/**
 * 创建默认Spark创作数据
 */
export function createDefaultSparkCreationData(sparkInput: string): SparkCreationData {
  const dialogState = createDefaultDialogState(sparkInput)
  
  return {
    id: generateId(),
    sparkInput,
    dialogState,
    outline: null,
    generationState: createDefaultGenerationState(),
    metadata: {
      tokenUsed: 0,
      timeCost: 0,
      completionRate: 0
    },
    status: 'draft',
    createdAt: new Date(),
    updatedAt: new Date()
  }
}

/**
 * 计算生成进度
 */
export function calculateGenerationProgress(outline: ArticleOutline): number {
  if (!outline.sections.length) return 0
  
  const completedSections = outline.sections.filter(
    section => section.status === SectionStatus.COMPLETED
  ).length
  
  return Math.round((completedSections / outline.sections.length) * 100)
}

/**
 * 获取下一个待生成段落
 */
export function getNextPendingSection(outline: ArticleOutline): OutlineSection | null {
  return outline.sections
    .sort((a, b) => a.order - b.order)
    .find(section => section.status === SectionStatus.PENDING) || null
}

/**
 * 验证用户响应完整性
 */
export function validateUserResponses(responses: Partial<UserResponses>): boolean {
  const requiredFields: (keyof UserResponses)[] = [
    'topic', 'purpose', 'audience', 'tone', 'totalWords', 'sectionCount'
  ]

  return requiredFields.every(field => {
    const value = responses[field]
    return value !== undefined && value !== null && value !== ''
  })
}

/**
 * 生成大纲标题建议
 */
export function generateOutlineTitleSuggestions(
  type: OutlineSectionType,
  topic: string
): string[] {
  switch (type) {
    case OutlineSectionType.INTRO:
      return [
        `${topic}概述`,
        `为什么关注${topic}`,
        `${topic}的重要性`,
        '引言',
        '背景介绍'
      ]
    case OutlineSectionType.BODY:
      return [
        `${topic}的核心要点`,
        `深入分析${topic}`,
        `${topic}的实践方法`,
        '详细论述',
        '主要内容'
      ]
    case OutlineSectionType.CONCLUSION:
      return [
        `${topic}总结`,
        '结论与建议',
        '未来展望',
        '行动指南',
        '总结'
      ]
    default:
      return ['标题建议']
  }
}